home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / tests / pager / pager.c < prev   
Encoding:
C/C++ Source or Header  |  1989-06-16  |  3.8 KB  |  144 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sprite.h>
  4. #include <option.h>
  5. #include <sys/time.h>
  6.  
  7.  
  8. int    pageSize = 4096;
  9. int    numPageFaults = 1000;
  10. int    repeats = 3;
  11. Boolean    pause = FALSE;
  12. Boolean    trace = FALSE;
  13. Boolean dirty = FALSE;
  14. Boolean longcheck = FALSE;
  15. Boolean staticArray = FALSE;
  16. static  char sArray[4*1024*1024];
  17.  
  18. Option optionArray[] = {
  19.     {OPT_INT, "p", (Address)&pageSize,
  20.     "The page size to fault on (default 4096)."},
  21.     {OPT_INT, "n", (Address)&numPageFaults,
  22.     "Number of page faults (default 1000)"},
  23.     {OPT_INT, "r", (Address)&repeats,
  24.     "Number of repeats of faulting sequence (default 3)"},
  25.     {OPT_TRUE, "P", (Address)&pause,
  26.     "Wait for input before starting"},
  27.     {OPT_TRUE, "t", (Address)&trace,
  28.     "Should print out information as page faults happen"},
  29.     {OPT_TRUE, "d", (Address)&dirty,
  30.     "Dirty the page on each pass."},
  31.     {OPT_TRUE, "c", (Address)&longcheck,
  32.     "Do a more complete check of the page."},
  33.     {OPT_TRUE, "s", (Address)&staticArray,
  34.     "Page from the static 4meg array."},
  35. };
  36. int numOptions = sizeof(optionArray) / sizeof(Option);
  37.  
  38. static char    *big;
  39.  
  40. main(argc, argv)
  41.     int  argc;
  42.     char *argv[];
  43. {
  44.     register    char    *bigPtr;
  45.     register    struct timeval    *beforeArr; 
  46.     register    struct timeval    *afterArr;
  47.     register    int    *intPtr;
  48.     register    int    i;
  49.     register    int    j;
  50.     struct    timeval        before, after;
  51.     char        *big;
  52.     char        c;
  53.     Boolean        once = FALSE;
  54.     double        rate;
  55.  
  56.     (void)Opt_Parse(argc, argv, optionArray, numOptions,0);
  57.     if (pause) {
  58.     scanf("%c", &c);
  59.     }
  60.     if (staticArray) {
  61.     big = sArray;
  62.     numPageFaults = 4*1024*1024/pageSize;
  63.     } else { 
  64.     big = (char *)malloc(pageSize * numPageFaults);
  65.     }
  66.     if (big == NULL) {
  67.     fprintf(stderr,"Can't allocated %d bytes of memory.\n",
  68.             pageSize * numPageFaults);
  69.     exit(1);
  70.     }
  71.     beforeArr = (struct timeval *)malloc(sizeof(struct timeval) * repeats);
  72.     afterArr = (struct timeval *)malloc(sizeof(struct timeval) * repeats);
  73.     if (beforeArr == NULL || afterArr == NULL) {
  74.     fprintf(stderr,"Can't allocated memory for timing arrays.\n");
  75.     exit(1);
  76.     }
  77.     gettimeofday(&before, NULL);
  78.     for (j = 0; j < repeats; j++) {
  79.     gettimeofday(&beforeArr[j], NULL);
  80.     for (i = 1, bigPtr = big; i <= numPageFaults; i++, bigPtr += pageSize) {
  81.         intPtr = (int *)bigPtr;
  82.         if (dirty) {
  83.         *intPtr = *intPtr;
  84.         }
  85.         if (!longcheck) {
  86.         if (once && *intPtr != i) {
  87.             printf("Error on page %d address 0x%x ", i, intPtr);
  88.             printf("Found 0x%x should be 0x%x\n",*intPtr,i);
  89.             fflush(stdout);
  90.             abort();
  91.         }
  92.         } else {
  93.         int    *end = intPtr + pageSize/sizeof(int);
  94.         int    *c;
  95.         if (once) {
  96.            for (c = intPtr; c < end; c += 4) {
  97.                if (*c != i) {
  98.                 printf("Error on page %d address 0x%x ", i,intPtr);
  99.                 printf("Found 0x%x should be 0x%x\n",*c,i);
  100.                 fflush(stdout);
  101.             }
  102.             }
  103.         }
  104.         }
  105.         if (trace && (i % 100 == 0)) {
  106.         printf("%d\n", i);
  107.         fflush(stdout);
  108.         }
  109.         if (!once || dirty) {
  110.         if (!longcheck) {
  111.             *intPtr = i;
  112.         } else {
  113.             int    *end = intPtr + pageSize/sizeof(int);
  114.             for (; intPtr < end; intPtr += 4) {
  115.             *intPtr = i;
  116.             }
  117.            }
  118.         }
  119.     }
  120.     gettimeofday(&afterArr[j], NULL);
  121.     once = TRUE;
  122.     if (trace) {
  123.         printf("Pass %d\n\n", j + 1);
  124.         fflush(stdout);
  125.     }
  126.     }
  127.     for (j = 0; j < repeats; j++) {
  128.     rate = (afterArr[j].tv_sec - beforeArr[j].tv_sec) * 1000;
  129.     rate += (afterArr[j].tv_usec - beforeArr[j].tv_usec) / 1000;
  130.     rate = rate / numPageFaults;
  131.     printf("Pass %d: %0.3f ms per page fault\n", j + 1, rate);
  132.     }
  133.  
  134.     gettimeofday(&after,NULL);
  135.     rate = (after.tv_sec - before.tv_sec) * 1000;
  136.     rate += (after.tv_usec - before.tv_usec)*.001;
  137.     rate = rate / (numPageFaults * repeats);
  138.     printf("Totals: time=%0.3f sec, faults=%d rate=%0.3f ms per fault\n", 
  139.         (after.tv_sec - before.tv_sec) + 
  140.         (after.tv_usec - before.tv_usec) / 1000000.0,
  141.         numPageFaults * repeats, rate);
  142.     exit(0);
  143. }
  144.